#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
微信API服务层
专门处理与微信API的直接交互
"""

import sys
import os
import logging
from typing import List, Dict, Any, Optional
from dao.account_dao import AccountDAO
from dao.message_dao import MessageDAO


# 添加pywechat路径到系统路径
sys.path.append(os.path.join(os.path.dirname(__file__), '..'))

from utils.pywechat.pywechat.interface import WechatAuto

class WechatAPIService:
    """
    微信API服务类
    负责处理所有与微信API的直接交互
    """
    
    def __init__(self):
        self.logger = logging.getLogger(__name__)
        self._wechat_auto = None
    
    @property
    def wechat_auto(self) -> Optional[WechatAuto]:
        """
        获取微信自动化实例
        
        Returns:
            Optional[WechatAuto]: 微信自动化实例
        """
        if self._wechat_auto is None:
            try:
                self._wechat_auto = WechatAuto()
                self.logger.info("微信自动化实例初始化成功")
            except Exception as e:
                self.logger.error(f"微信自动化实例初始化失败: {e}")
                # 初始化失败时返回None
                return None
        return self._wechat_auto
    
    def send_message_to_friend(self,account_id: str, friend_name: str, message: str) -> str:

        """
        发送消息给好友
        
        Args:
            account_id (str): 当前用户账号

            friend_name (str): 好友名称
            message (str): 消息内容
            
        Returns:
            str: 消息ID
        """


        account_dao = AccountDAO()
        owner = account_dao.get_account_by_id(account_id)


        try:
            if self.wechat_auto:
                # 记录调试信息
                self.logger.info(f"准备发送消息给好友: {friend_name}, 消息内容: {message}")
                
                # 实际发送消息 - 使用位置参数而不是关键字参数
                result = self.wechat_auto.send_message_to_friend(friend_name, message)
                self.logger.info(f"发送消息结果: {result}")
                
                # 将发送的消息记录保存到数据库中
                message_dao = MessageDAO()
                # 已经在方法开始时获取了owner，不需要重复获取

                message_data = {
                    'account': account_id,
                    'sender': owner.alias,
                    'receiver': friend_name,
                    'content': message,
                    'message_type': 'text',  # 默认为文本消息
                    'chat_type': 'private',  # 私聊
                    'direction': 'sent',     # 发送
                    'status': 'success' if result else 'failed'
                }
                message_id = message_dao.save_message(message_data)
                
                return message_id
            else:
                self.logger.error("微信自动化实例未初始化")
                return False
        except Exception as e:
            self.logger.error(f"发送消息给好友失败: {e}")
            return False


    def send_message_to_friend_by_id(self, friend_id: str, message: str) -> bool:
        """
        发送消息给好友

        Args:
            friend_id (str): 好友ID
            message (str): 消息内容

        Returns:
            bool: 发送是否成功
        """
        try:
            if self.wechat_auto:
                # 记录调试信息
                self.logger.info(f"准备发送消息给好友: {friend_id}, 消息内容: {message}")
                result = self.wechat_auto.send_message_to_friend_by_id(friend_id, message)

                self.logger.info(f"发送消息结果: {result}")
                
                # 将发送的消息记录保存到数据库中
                message_dao = MessageDAO()
                message_data = {
                    'account': 'default',  # 使用默认账号，因为该方法没有account参数
                    'sender': 'self',
                    'receiver': friend_id,
                    'content': message,
                    'message_type': 'text',  # 默认为文本消息
                    'chat_type': 'private',  # 私聊
                    'direction': 'sent',     # 发送
                    'status': 'success' if result else 'failed'
                }
                message_dao.save_message(message_data)
                
                return True
            else:
                self.logger.error("微信自动化实例未初始化")
                return False
            return True
        except Exception as e:
            self.logger.error(f"发送消息给好友失败: {e}")
            return False
    
    def send_message_to_group(self, account_id: str, group_name: str, message: str) -> bool:
        """
        发送消息到群聊
        
        Args:
            group_name (str): 群聊名称
            message (str): 消息内容
            
        Returns:
            bool: 发送是否成功
        """
        try:
            if self.wechat_auto:
                # 记录调试信息
                self.logger.info(f"准备发送消息给群组: {group_name}, 消息内容: {message}")
                
                # 实际发送消息 - 使用位置参数而不是关键字参数
                result = self.wechat_auto.send_message_to_friend(group_name, message)
                self.logger.info(f"发送消息结果: {result}")
                
                # 将发送的消息记录保存到数据库中
                message_dao = MessageDAO()
                message_data = {
                    'account': account_id,  # 使用传入的账号ID
                    'sender': 'self',
                    'receiver': group_name,
                    'content': message,
                    'message_type': 'text',  # 默认为文本消息
                    'chat_type': 'group',   # 群聊
                    'direction': 'sent',     # 发送
                    'status': 'success' if result else 'failed'
                }
                message_dao.save_message(message_data)
                
                return True
            else:
                self.logger.error("微信自动化实例未初始化")
                return False
        except Exception as e:
            self.logger.error(f"发送消息到群聊失败: {e}")
            return False
    
    def check_new_messages(self, duration: str = "10s") -> List[Dict[str, Any]]:
        """
        检查新消息
        
        Args:
            duration (str): 检查时长
            
        Returns:
            List[Dict[str, Any]]: 当前周期内的新消息列表
        """
        try:
            if not hasattr(self, '_processed_messages'):
                self._processed_messages = set()  # 用于存储已处理过的消息标识
                
            if self.wechat_auto:
                new_messages = self.wechat_auto.check_new_message(
                    duration=duration
                )
                
                # 如果没有新消息，直接返回空列表
                if not new_messages:
                    return []
                
                # 过滤出当前周期内的新消息
                current_messages = []
                for message in new_messages:
                    # 创建消息的唯一标识（使用好友名称、消息条数和消息内容的组合）
                    message_id = self._create_message_id(message)
                    
                    # 如果消息未被处理过，则添加到当前消息列表
                    if message_id not in self._processed_messages:
                        self._processed_messages.add(message_id)
                        current_messages.append(message)
                
                self.logger.info(f"当前周期检测到 {len(current_messages)} 条新消息")
                return current_messages
            else:
                self.logger.error("微信自动化实例未初始化")
                return []
        except Exception as e:
            self.logger.error(f"检查新消息失败: {e}")
            return []
            
    def _create_message_id(self, message: Dict[str, Any]) -> str:
        """
        创建消息的唯一标识
        
        Args:
            message (Dict[str, Any]): 消息数据
            
        Returns:
            str: 消息唯一标识
        """
        # 基于好友名称和消息条数创建基础标识
        base_id = f"{message.get('好友名称', '')}_{message.get('新消息条数', 0)}"
        
        # 如果消息中包含消息内容，则将最后一条消息内容也加入标识
        if '消息内容' in message and message['消息内容']:
            # 取最后一条消息的内容作为标识的一部分
            last_message = message['消息内容'][-1] if isinstance(message['消息内容'], list) else message['消息内容']
            return f"{base_id}_{last_message}"
        
        return base_id
        
    def reset_message_cache(self):
        """
        重置消息缓存
        在需要重新开始检测新消息的周期时调用此方法
        """
        if hasattr(self, '_processed_messages'):
            self._processed_messages.clear()
            self.logger.info("已重置消息缓存")
        else:
            self._processed_messages = set()
            self.logger.info("已初始化消息缓存")